home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Magazine / Morphos / GCC / os-includeppc / inline / macros.h < prev    next >
C/C++ Source or Header  |  1998-12-26  |  68KB  |  1,418 lines
  1. #ifndef __INLINE_MACROS_H
  2. #define __INLINE_MACROS_H
  3.  
  4. #include <powerup/gcclib/powerup_protos.h>
  5.  
  6. /* Use these macros to calculate cache flush start address and cache flush
  7. length. */
  8. #define __CACHE_START(start) ((void *) ((unsigned long int) (start) & ~31))
  9. #define __CACHE_LENGTH(start,length) ((((length) + (unsigned long int) (start) + 31) & ~31) - ((unsigned long int) (start) & ~31))
  10.  
  11. /*
  12.    General macros for Amiga function calls. Not all the possibilities have
  13.    been created - only the ones which exist in OS 3.1. Third party libraries
  14.    and future versions of AmigaOS will maybe need some new ones...
  15.  
  16.    LPX - functions that take X arguments.
  17.  
  18.    Modifiers (variations are possible):
  19.    NR - no return (void),
  20.    A4, A5 - "a4" or "a5" is used as one of the arguments,
  21.    UB - base will be given explicitly by user (see cia.resource).
  22.    FP - one of the parameters has type "pointer to function".
  23.  
  24.    "bt" arguments are not used - they are provided for backward compatibility
  25.    only.
  26.    Actually..the "bt" parameter is needed because otherwise the macro doesn`t
  27.    work for some reason i don`t know gcc puts an empty argument at the position
  28.    before the argument bn and without the placeholder "bt".
  29.    I think it has something to do with #define *_BASE_NAME
  30.  
  31.    the (cm1==IF_CACHEFLUSHAREA) conditional is optimized away
  32. */
  33.  
  34. #ifndef __INLINE_STUB_H
  35. #include <powerup/ppcinline/stubs.h>
  36. #endif
  37.  
  38. #ifndef POWERUP_PPCLIB_INTERFACE_H
  39. #include <powerup/ppclib/interface.h>
  40. #endif
  41.  
  42. #ifndef WARPUP /* PowerUp */
  43.  
  44. #define LP0(offs, rt, name, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )  \
  45. ({                              \
  46.    struct Caos *MyCaos;                     \
  47.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  48.    {                                \
  49.       rt _##name##_re;                      \
  50.       MyCaos->a6        = (ULONG) bn;           \
  51.       MyCaos->M68kCacheMode =   cm1;            \
  52.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))   \
  53.       {                             \
  54.         MyCaos->M68kStart   =   cs1;            \
  55.         MyCaos->M68kLength  =   cl1;            \
  56.       }                             \
  57.       MyCaos->PPCCacheMode  =   cm2;            \
  58.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))   \
  59.       {                             \
  60.         MyCaos->PPCStart    =   cs2;            \
  61.         MyCaos->PPCLength   =   cl2;            \
  62.       }                             \
  63.       MyCaos->caos_Un.Offset    =   (-offs);        \
  64.       _##name##_re = (rt) PPCCallOS (MyCaos);           \
  65.       _##name##_re;                     \
  66.    }                                \
  67. })
  68.  
  69. #define LP0NR(offs, name, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  70. ({                              \
  71.    struct Caos *MyCaos;                     \
  72.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  73.    {                                \
  74.       MyCaos->a6        = (ULONG) bn;           \
  75.       MyCaos->M68kCacheMode =   cm1;            \
  76.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))   \
  77.       {                             \
  78.         MyCaos->M68kStart   =   cs1;            \
  79.         MyCaos->M68kLength  =   cl1;            \
  80.       }                             \
  81.       MyCaos->PPCCacheMode  =   cm2;            \
  82.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))   \
  83.       {                             \
  84.         MyCaos->PPCStart    =   cs2;            \
  85.         MyCaos->PPCLength   =   cl2;            \
  86.       }                             \
  87.       MyCaos->caos_Un.Offset    =   (-offs);        \
  88.       PPCCallOS (MyCaos);                   \
  89.    }                                \
  90. })
  91.  
  92. #define LP1(offs, rt, name, t1, v1, r1, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )  \
  93. ({                              \
  94.    struct Caos *MyCaos;                     \
  95.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  96.    {                                \
  97.       rt _##name##_re;                      \
  98.       MyCaos->##r1      = (ULONG) v1;           \
  99.       MyCaos->a6        = (ULONG) bn;           \
  100.       MyCaos->M68kCacheMode =   cm1;            \
  101.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))   \
  102.       {                             \
  103.         MyCaos->M68kStart   =   cs1;            \
  104.         MyCaos->M68kLength  =   cl1;            \
  105.       }                             \
  106.       MyCaos->PPCCacheMode  =   cm2;            \
  107.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))   \
  108.       {                             \
  109.         MyCaos->PPCStart    =   cs2;            \
  110.         MyCaos->PPCLength   =   cl2;            \
  111.       }                             \
  112.       MyCaos->caos_Un.Offset    =   (-offs);        \
  113.       _##name##_re = (rt) PPCCallOS (MyCaos);           \
  114.       _##name##_re;                     \
  115.    }                                \
  116. })
  117.  
  118. #define LP1NR(offs, name, t1, v1, r1, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  119. ({                              \
  120.    struct Caos *MyCaos;                     \
  121.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  122.    {                                \
  123.       MyCaos->##r1      = (ULONG) v1;           \
  124.       MyCaos->a6        = (ULONG) bn;           \
  125.       MyCaos->M68kCacheMode =   cm1;            \
  126.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))   \
  127.       {                             \
  128.         MyCaos->M68kStart   =   cs1;            \
  129.         MyCaos->M68kLength  =   cl1;            \
  130.       }                             \
  131.       MyCaos->PPCCacheMode  =   cm2;            \
  132.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))   \
  133.       {                             \
  134.         MyCaos->PPCStart    =   cs2;            \
  135.         MyCaos->PPCLength   =   cl2;            \
  136.       }                             \
  137.       MyCaos->caos_Un.Offset    =   (-offs);        \
  138.       PPCCallOS (MyCaos);                   \
  139.    }                                \
  140. })
  141.  
  142. /* Only graphics.library/AttemptLockLayerRom() */
  143. #define LP1A5(offs, rt, name, t1, v1, r1, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  144. ({                              \
  145.    struct Caos *MyCaos;                     \
  146.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  147.    {                                \
  148.       rt _##name##_re;                      \
  149.       MyCaos->##r1      = (ULONG) v1;           \
  150.       MyCaos->a6        = (ULONG) bn;           \
  151.       MyCaos->M68kCacheMode =   cm1;            \
  152.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))   \
  153.       {                             \
  154.         MyCaos->M68kStart   =   cs1;            \
  155.         MyCaos->M68kLength  =   cl1;            \
  156.       }                             \
  157.       MyCaos->PPCCacheMode  =   cm2;            \
  158.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))   \
  159.       {                             \
  160.         MyCaos->PPCStart    =   cs2;            \
  161.         MyCaos->PPCLength   =   cl2;            \
  162.       }                             \
  163.       MyCaos->caos_Un.Offset    =   (-offs);        \
  164.       _##name##_re = (rt) PPCCallOS (MyCaos);           \
  165.       _##name##_re;                     \
  166.    }                                \
  167. })
  168.  
  169. /* Only graphics.library/LockLayerRom() and graphics.library/UnlockLayerRom() */
  170. #define LP1NRA5(offs, name, t1, v1, r1, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )  \
  171. ({                              \
  172.    struct Caos *MyCaos;                     \
  173.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  174.    {                                \
  175.       MyCaos->##r1      = (ULONG) v1;           \
  176.       MyCaos->a6        = (ULONG) bn;           \
  177.       MyCaos->M68kCacheMode =   cm1;            \
  178.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))   \
  179.       {                             \
  180.         MyCaos->M68kStart   =   cs1;            \
  181.         MyCaos->M68kLength  =   cl1;            \
  182.       }                             \
  183.       MyCaos->PPCCacheMode  =   cm2;            \
  184.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))   \
  185.       {                             \
  186.         MyCaos->PPCStart    =   cs2;            \
  187.         MyCaos->PPCLength   =   cl2;            \
  188.       }                             \
  189.       MyCaos->caos_Un.Offset    =   (-offs);        \
  190.       PPCCallOS (MyCaos);                   \
  191.    }                                \
  192. })
  193.  
  194. /* Only exec.library/Supervisor() */
  195. #define LP1A5FP(offs, rt, name, t1, v1, r1, bt, bn, fpt, cm1, cs1, cl1, cm2, cs2, cl2 ) \
  196. ({                              \
  197.    typedef fpt;                         \
  198.    struct Caos *MyCaos;                     \
  199.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  200.    {                                \
  201.       rt _##name##_re;                      \
  202.       MyCaos->##r1      = (ULONG) v1;           \
  203.       MyCaos->a6        = (ULONG) bn;           \
  204.       MyCaos->M68kCacheMode =   cm1;            \
  205.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))   \
  206.       {                             \
  207.         MyCaos->M68kStart   =   cs1;            \
  208.         MyCaos->M68kLength  =   cl1;            \
  209.       }                             \
  210.       MyCaos->PPCCacheMode  =   cm2;            \
  211.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))   \
  212.       {                             \
  213.         MyCaos->PPCStart    =   cs2;            \
  214.         MyCaos->PPCLength   =   cl2;            \
  215.       }                             \
  216.       MyCaos->caos_Un.Offset    =   (-offs);        \
  217.       _##name##_re = (rt) PPCCallOS (MyCaos);           \
  218.       _##name##_re;                     \
  219.    }                                \
  220. })
  221.  
  222.  
  223. #define LP2(offs, rt, name, t1, v1, r1, t2, v2, r2, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )  \
  224. ({                              \
  225.    struct Caos *MyCaos;                     \
  226.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  227.    {                                \
  228.       rt _##name##_re;                      \
  229.       MyCaos->##r1      = (ULONG) v1;           \
  230.       MyCaos->##r2      = (ULONG) v2;           \
  231.       MyCaos->a6        = (ULONG) bn;           \
  232.       MyCaos->M68kCacheMode =   cm1;            \
  233.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))   \
  234.       {                             \
  235.         MyCaos->M68kStart   =   cs1;            \
  236.         MyCaos->M68kLength  =   cl1;            \
  237.       }                             \
  238.       MyCaos->PPCCacheMode  =   cm2;            \
  239.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))   \
  240.       {                             \
  241.         MyCaos->PPCStart    =   cs2;            \
  242.         MyCaos->PPCLength   =   cl2;            \
  243.       }                             \
  244.       MyCaos->caos_Un.Offset    =   (-offs);        \
  245.       _##name##_re = (rt) PPCCallOS (MyCaos);                   \
  246.       _##name##_re;                     \
  247.    }                                \
  248. })
  249.  
  250. #define LP2NR(offs, name, t1, v1, r1, t2, v2, r2, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  251. ({                              \
  252.    struct Caos *MyCaos;                     \
  253.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  254.    {                                \
  255.       MyCaos->##r1      = (ULONG) v1;           \
  256.       MyCaos->##r2      = (ULONG) v2;           \
  257.       MyCaos->a6        = (ULONG) bn;           \
  258.       MyCaos->M68kCacheMode =   cm1;            \
  259.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))   \
  260.       {                             \
  261.         MyCaos->M68kStart   =   cs1;            \
  262.         MyCaos->M68kLength  =   cl1;            \
  263.       }                             \
  264.       MyCaos->PPCCacheMode  =   cm2;            \
  265.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))   \
  266.       {                             \
  267.         MyCaos->PPCStart    =   cs2;            \
  268.         MyCaos->PPCLength   =   cl2;            \
  269.       }                             \
  270.       MyCaos->caos_Un.Offset    =   (-offs);        \
  271.       PPCCallOS (MyCaos);                   \
  272.    }                                \
  273. })
  274.  
  275. /* Only cia.resource/AbleICR() and cia.resource/SetICR() */
  276. #define LP2UB(offs, rt, name, t1, v1, r1, t2, v2, r2, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  277. ({                              \
  278.    struct Caos *MyCaos;                     \
  279.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  280.    {                                \
  281.       rt _##name##_re;                      \
  282.       MyCaos->##r1      = (ULONG) v1;           \
  283.       MyCaos->##r2      = (ULONG) v2;           \
  284.       MyCaos->M68kCacheMode =   cm1;            \
  285.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))   \
  286.       {                             \
  287.         MyCaos->M68kStart   =   cs1;            \
  288.         MyCaos->M68kLength  =   cl1;            \
  289.       }                             \
  290.       MyCaos->PPCCacheMode  =   cm2;            \
  291.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))   \
  292.       {                             \
  293.         MyCaos->PPCStart    =   cs2;            \
  294.         MyCaos->PPCLength   =   cl2;            \
  295.       }                             \
  296.       MyCaos->caos_Un.Offset    =   (-offs);        \
  297.       _##name##_re = (rt) PPCCallOS (MyCaos);           \
  298.       _##name##_re;                     \
  299.    }                                \
  300. })
  301.  
  302. /* Only dos.library/InternalUnLoadSeg() */
  303. #define LP2FP(offs, rt, name, t1, v1, r1, t2, v2, r2, bt, bn, fpt, cm1, cs1, cl1, cm2, cs2, cl2 )   \
  304. ({                              \
  305.    typedef fpt;                         \
  306.    struct Caos *MyCaos;                     \
  307.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  308.    {                                \
  309.       rt _##name##_re;                      \
  310.       MyCaos->##r1      = (ULONG) v1;           \
  311.       MyCaos->##r2      = (ULONG) v2;           \
  312.       MyCaos->a6        = (ULONG) bn;           \
  313.       MyCaos->M68kCacheMode =   cm1;            \
  314.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))   \
  315.       {                             \
  316.         MyCaos->M68kStart   =   cs1;            \
  317.         MyCaos->M68kLength  =   cl1;            \
  318.       }                             \
  319.       MyCaos->PPCCacheMode  =   cm2;            \
  320.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))   \
  321.       {                             \
  322.         MyCaos->PPCStart    =   cs2;            \
  323.         MyCaos->PPCLength   =   cl2;            \
  324.       }                             \
  325.       MyCaos->caos_Un.Offset    =   (-offs);        \
  326.       _##name##_re = (rt) PPCCallOS (MyCaos);           \
  327.       _##name##_re;                     \
  328.    }                                \
  329. })
  330.  
  331. #define LP3(offs, rt, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )  \
  332. ({                              \
  333.    struct Caos *MyCaos;                     \
  334.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  335.    {                                \
  336.       rt _##name##_re;                      \
  337.       MyCaos->##r1      = (ULONG) v1;           \
  338.       MyCaos->##r2      = (ULONG) v2;           \
  339.       MyCaos->##r3      = (ULONG) v3;           \
  340.       MyCaos->a6        = (ULONG) bn;           \
  341.       MyCaos->M68kCacheMode =   cm1;            \
  342.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))   \
  343.       {                             \
  344.         MyCaos->M68kStart   =   cs1;            \
  345.         MyCaos->M68kLength  =   cl1;            \
  346.       }                             \
  347.       MyCaos->PPCCacheMode  =   cm2;            \
  348.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))   \
  349.       {                             \
  350.         MyCaos->PPCStart    =   cs2;            \
  351.         MyCaos->PPCLength   =   cl2;            \
  352.       }                             \
  353.       MyCaos->caos_Un.Offset    =   (-offs);        \
  354.       _##name##_re = (rt) PPCCallOS (MyCaos);           \
  355.       _##name##_re;                     \
  356.    }                                \
  357. })
  358.  
  359. #define LP3NR(offs, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  360. ({                              \
  361.    struct Caos *MyCaos;                     \
  362.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  363.    {                                \
  364.       MyCaos->##r1      = (ULONG) v1;           \
  365.       MyCaos->##r2      = (ULONG) v2;           \
  366.       MyCaos->##r3      = (ULONG) v3;           \
  367.       MyCaos->a6        = (ULONG) bn;           \
  368.       MyCaos->M68kCacheMode =   cm1;            \
  369.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))   \
  370.       {                             \
  371.         MyCaos->M68kStart   =   cs1;            \
  372.         MyCaos->M68kLength  =   cl1;            \
  373.       }                             \
  374.       MyCaos->PPCCacheMode  =   cm2;            \
  375.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))   \
  376.       {                             \
  377.         MyCaos->PPCStart    =   cs2;            \
  378.         MyCaos->PPCLength   =   cl2;            \
  379.       }                             \
  380.       MyCaos->caos_Un.Offset    =   (-offs);        \
  381.       PPCCallOS (MyCaos);                   \
  382.    }                                \
  383. })
  384.  
  385. /* Only cia.resource/AddICRVector() */
  386. #define LP3UB(offs, rt, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  387. ({                              \
  388.    struct Caos *MyCaos;                     \
  389.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  390.    {                                \
  391.       rt _##name##_re;                      \
  392.       MyCaos->##r1      = (ULONG) v1;           \
  393.       MyCaos->##r2      = (ULONG) v2;           \
  394.       MyCaos->##r3      = (ULONG) v3;           \
  395.       MyCaos->M68kCacheMode =   cm1;            \
  396.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))   \
  397.       {                             \
  398.         MyCaos->M68kStart   =   cs1;            \
  399.         MyCaos->M68kLength  =   cl1;            \
  400.       }                             \
  401.       MyCaos->PPCCacheMode  =   cm2;            \
  402.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))   \
  403.       {                             \
  404.         MyCaos->PPCStart    =   cs2;            \
  405.         MyCaos->PPCLength   =   cl2;            \
  406.       }                             \
  407.       MyCaos->caos_Un.Offset    =   (-offs);        \
  408.       _##name##_re = (rt) PPCCallOS (MyCaos);           \
  409.       _##name##_re;                     \
  410.    }                                \
  411. })
  412.  
  413. /* Only cia.resource/RemICRVector() */
  414. #define LP3NRUB(offs, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, cm1, cs1, cl1, cm2, cs2, cl2 )  \
  415. ({                              \
  416.    struct Caos *MyCaos;                     \
  417.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  418.    {                                \
  419.       MyCaos->##r1      = (ULONG) v1;           \
  420.       MyCaos->##r2      = (ULONG) v2;           \
  421.       MyCaos->##r3      = (ULONG) v3;           \
  422.       MyCaos->M68kCacheMode =   cm1;            \
  423.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))   \
  424.       {                             \
  425.         MyCaos->M68kStart   =   cs1;            \
  426.         MyCaos->M68kLength  =   cl1;            \
  427.       }                             \
  428.       MyCaos->PPCCacheMode  =   cm2;            \
  429.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))   \
  430.       {                             \
  431.         MyCaos->PPCStart    =   cs2;            \
  432.         MyCaos->PPCLength   =   cl2;            \
  433.       }                             \
  434.       MyCaos->caos_Un.Offset    =   (-offs);        \
  435.       PPCCallOS (MyCaos);                   \
  436.    }                                \
  437. })
  438.  
  439. /* Only exec.library/SetFunction() */
  440. #define LP3FP(offs, rt, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, bt, bn, fpt, cm1, cs1, cl1, cm2, cs2, cl2 )   \
  441. ({                              \
  442.    typedef fpt;                         \
  443.    struct Caos *MyCaos;                     \
  444.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  445.    {                                \
  446.       rt _##name##_re;                      \
  447.       MyCaos->##r1      = (ULONG) v1;           \
  448.       MyCaos->##r2      = (ULONG) v2;           \
  449.       MyCaos->##r3      = (ULONG) v3;           \
  450.       MyCaos->a6        = (ULONG) bn;           \
  451.       MyCaos->M68kCacheMode =   cm1;            \
  452.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))   \
  453.       {                             \
  454.         MyCaos->M68kStart   =   cs1;            \
  455.         MyCaos->M68kLength  =   cl1;            \
  456.       }                             \
  457.       MyCaos->PPCCacheMode  =   cm2;            \
  458.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))   \
  459.       {                             \
  460.         MyCaos->PPCStart    =   cs2;            \
  461.         MyCaos->PPCLength   =   cl2;            \
  462.       }                             \
  463.       MyCaos->caos_Un.Offset    =   (-offs);        \
  464.       _##name##_re = (rt) PPCCallOS (MyCaos);           \
  465.       _##name##_re;                     \
  466.    }                                \
  467. })
  468.  
  469. /* Only graphics.library/SetCollision() */
  470. #define LP3NRFP(offs, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, bt, bn, fpt, cm1, cs1, cl1, cm2, cs2, cl2 ) \
  471. ({                              \
  472.    typedef fpt;                         \
  473.    struct Caos *MyCaos;                     \
  474.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  475.    {                                \
  476.       MyCaos->##r1      = (ULONG) v1;           \
  477.       MyCaos->##r2      = (ULONG) v2;           \
  478.       MyCaos->##r3      = (ULONG) v3;           \
  479.       MyCaos->a6        = (ULONG) bn;           \
  480.       MyCaos->M68kCacheMode =   cm1;            \
  481.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))   \
  482.       {                             \
  483.         MyCaos->M68kStart   =   cs1;            \
  484.         MyCaos->M68kLength  =   cl1;            \
  485.       }                             \
  486.       MyCaos->PPCCacheMode  =   cm2;            \
  487.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))   \
  488.       {                             \
  489.         MyCaos->PPCStart    =   cs2;            \
  490.         MyCaos->PPCLength   =   cl2;            \
  491.       }                             \
  492.       MyCaos->caos_Un.Offset    =   (-offs);        \
  493.       PPCCallOS (MyCaos);                   \
  494.    }                                \
  495. })
  496.  
  497. #define LP4(offs, rt, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )  \
  498. ({                              \
  499.    struct Caos *MyCaos;                     \
  500.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  501.    {                                \
  502.       rt _##name##_re;                      \
  503.       MyCaos->##r1      = (ULONG) v1;           \
  504.       MyCaos->##r2      = (ULONG) v2;           \
  505.       MyCaos->##r3      = (ULONG) v3;           \
  506.       MyCaos->##r4      = (ULONG) v4;           \
  507.       MyCaos->a6        = (ULONG) bn;           \
  508.       MyCaos->M68kCacheMode =   cm1;            \
  509.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))   \
  510.       {                             \
  511.         MyCaos->M68kStart   =   cs1;            \
  512.         MyCaos->M68kLength  =   cl1;            \
  513.       }                             \
  514.       MyCaos->PPCCacheMode  =   cm2;            \
  515.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))   \
  516.       {                             \
  517.         MyCaos->PPCStart    =   cs2;            \
  518.         MyCaos->PPCLength   =   cl2;            \
  519.       }                             \
  520.       MyCaos->caos_Un.Offset    =   (-offs);        \
  521.       _##name##_re = (rt) PPCCallOS (MyCaos);           \
  522.       _##name##_re;                     \
  523.    }                                \
  524. })
  525.  
  526. #define LP4NR(offs, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  527. ({                              \
  528.    struct Caos *MyCaos;                     \
  529.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  530.    {                                \
  531.       MyCaos->##r1      = (ULONG) v1;           \
  532.       MyCaos->##r2      = (ULONG) v2;           \
  533.       MyCaos->##r3      = (ULONG) v3;           \
  534.       MyCaos->##r4      = (ULONG) v4;           \
  535.       MyCaos->a6        = (ULONG) bn;           \
  536.       MyCaos->M68kCacheMode =   cm1;            \
  537.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))   \
  538.       {                             \
  539.         MyCaos->M68kStart   =   cs1;            \
  540.         MyCaos->M68kLength  =   cl1;            \
  541.       }                             \
  542.       MyCaos->PPCCacheMode  =   cm2;            \
  543.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))   \
  544.       {                             \
  545.         MyCaos->PPCStart    =   cs2;            \
  546.         MyCaos->PPCLength   =   cl2;            \
  547.       }                             \
  548.       MyCaos->caos_Un.Offset    =   (-offs);        \
  549.       PPCCallOS (MyCaos);                   \
  550.    }                                \
  551. })
  552.  
  553. /* Only exec.library/RawDoFmt() */
  554. #define LP4FP(offs, rt, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, bt, bn, fpt, cm1, cs1, cl1, cm2, cs2, cl2 )   \
  555. ({                              \
  556.    typedef fpt;                         \
  557.    struct Caos *MyCaos;                     \
  558.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  559.    {                                \
  560.       rt _##name##_re;                      \
  561.       MyCaos->##r1      = (ULONG) v1;           \
  562.       MyCaos->##r2      = (ULONG) v2;           \
  563.       MyCaos->##r3      = (ULONG) v3;           \
  564.       MyCaos->##r4      = (ULONG) v4;           \
  565.       MyCaos->a6        = (ULONG) bn;           \
  566.       MyCaos->M68kCacheMode =   cm1;            \
  567.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))   \
  568.       {                             \
  569.         MyCaos->M68kStart   =   cs1;            \
  570.         MyCaos->M68kLength  =   cl1;            \
  571.       }                             \
  572.       MyCaos->PPCCacheMode  =   cm2;            \
  573.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))   \
  574.       {                             \
  575.         MyCaos->PPCStart    =   cs2;            \
  576.         MyCaos->PPCLength   =   cl2;            \
  577.       }                             \
  578.       MyCaos->caos_Un.Offset    =   (-offs);        \
  579.       _##name##_re = (rt) PPCCallOS (MyCaos);           \
  580.       _##name##_re;                     \
  581.    }                                \
  582. })
  583.  
  584. #define LP5(offs, rt, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, t5, v5, r5, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )  \
  585. ({                              \
  586.    struct Caos *MyCaos;                     \
  587.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  588.    {                                \
  589.       rt _##name##_re;                      \
  590.       MyCaos->##r1      = (ULONG) v1;           \
  591.       MyCaos->##r2      = (ULONG) v2;           \
  592.       MyCaos->##r3      = (ULONG) v3;           \
  593.       MyCaos->##r4      = (ULONG) v4;           \
  594.       MyCaos->##r5      = (ULONG) v5;           \
  595.       MyCaos->a6        = (ULONG) bn;           \
  596.       MyCaos->M68kCacheMode =   cm1;            \
  597.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))   \
  598.       {                             \
  599.         MyCaos->M68kStart   =   cs1;            \
  600.         MyCaos->M68kLength  =   cl1;            \
  601.       }                             \
  602.       MyCaos->PPCCacheMode  =   cm2;            \
  603.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))   \
  604.       {                             \
  605.         MyCaos->PPCStart    =   cs2;            \
  606.         MyCaos->PPCLength   =   cl2;            \
  607.       }                             \
  608.       MyCaos->caos_Un.Offset    =   (-offs);        \
  609.       _##name##_re = (rt) PPCCallOS (MyCaos);           \
  610.       _##name##_re;                     \
  611.    }                                \
  612. })
  613.  
  614. #define LP5NR(offs, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, t5, v5, r5, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  615. ({                              \
  616.    struct Caos *MyCaos;                     \
  617.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  618.    {                                \
  619.       MyCaos->##r1      = (ULONG) v1;           \
  620.       MyCaos->##r2      = (ULONG) v2;           \
  621.       MyCaos->##r3      = (ULONG) v3;           \
  622.       MyCaos->##r4      = (ULONG) v4;           \
  623.       MyCaos->##r5      = (ULONG) v5;           \
  624.       MyCaos->a6        = (ULONG) bn;           \
  625.       MyCaos->M68kCacheMode =   cm1;            \
  626.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))   \
  627.       {                             \
  628.         MyCaos->M68kStart   =   cs1;            \
  629.         MyCaos->M68kLength  =   cl1;            \
  630.       }                             \
  631.       MyCaos->PPCCacheMode  =   cm2;            \
  632.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))   \
  633.       {                             \
  634.         MyCaos->PPCStart    =   cs2;            \
  635.         MyCaos->PPCLength   =   cl2;            \
  636.       }                             \
  637.       MyCaos->caos_Un.Offset    =   (-offs);        \
  638.       PPCCallOS (MyCaos);                   \
  639.    }                                \
  640. })
  641.  
  642. /* Only exec.library/MakeLibrary() */
  643. #define LP5FP(offs, rt, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, t5, v5, r5, bt, bn, fpt, cm1, cs1, cl1, cm2, cs2, cl2 )   \
  644. ({                              \
  645.    typedef fpt;                         \
  646.    struct Caos *MyCaos;                     \
  647.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  648.    {                                \
  649.       rt _##name##_re;                      \
  650.       MyCaos->##r1      = (ULONG) v1;           \
  651.       MyCaos->##r2      = (ULONG) v2;           \
  652.       MyCaos->##r3      = (ULONG) v3;           \
  653.       MyCaos->##r4      = (ULONG) v4;           \
  654.       MyCaos->##r5      = (ULONG) v5;           \
  655.       MyCaos->a6        = (ULONG) bn;           \
  656.       MyCaos->M68kCacheMode =   cm1;            \
  657.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))   \
  658.       {                             \
  659.         MyCaos->M68kStart   =   cs1;            \
  660.         MyCaos->M68kLength  =   cl1;            \
  661.       }                             \
  662.       MyCaos->PPCCacheMode  =   cm2;            \
  663.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))   \
  664.       {                             \
  665.         MyCaos->PPCStart    =   cs2;            \
  666.         MyCaos->PPCLength   =   cl2;            \
  667.       }                             \
  668.       MyCaos->caos_Un.Offset    =   (-offs);        \
  669.       _##name##_re = (rt) PPCCallOS (MyCaos);           \
  670.       _##name##_re;                     \
  671.    }                                \
  672. })
  673.  
  674. #define LP6(offs, rt, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, t5, v5, r5, t6, v6, r6, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )  \
  675. ({                              \
  676.    struct Caos *MyCaos;                     \
  677.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  678.    {                                \
  679.       rt _##name##_re;                      \
  680.       MyCaos->##r1      = (ULONG) v1;           \
  681.       MyCaos->##r2      = (ULONG) v2;           \
  682.       MyCaos->##r3      = (ULONG) v3;           \
  683.       MyCaos->##r4      = (ULONG) v4;           \
  684.       MyCaos->##r5      = (ULONG) v5;           \
  685.       MyCaos->##r6      = (ULONG) v6;           \
  686.       MyCaos->a6        = (ULONG) bn;           \
  687.       MyCaos->M68kCacheMode =   cm1;            \
  688.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))   \
  689.       {                             \
  690.         MyCaos->M68kStart   =   cs1;            \
  691.         MyCaos->M68kLength  =   cl1;            \
  692.       }                             \
  693.       MyCaos->PPCCacheMode  =   cm2;            \
  694.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))   \
  695.       {                             \
  696.         MyCaos->PPCStart    =   cs2;            \
  697.         MyCaos->PPCLength   =   cl2;            \
  698.       }                             \
  699.       MyCaos->caos_Un.Offset    =   (-offs);        \
  700.       _##name##_re = (rt) PPCCallOS (MyCaos);           \
  701.       _##name##_re;                     \
  702.    }                                \
  703. })
  704.  
  705. #define LP6NR(offs, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, t5, v5, r5, t6, v6, r6, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  706. ({                              \
  707.    struct Caos *MyCaos;                     \
  708.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  709.    {                                \
  710.       MyCaos->##r1      = (ULONG) v1;           \
  711.       MyCaos->##r2      = (ULONG) v2;           \
  712.       MyCaos->##r3      = (ULONG) v3;           \
  713.       MyCaos->##r4      = (ULONG) v4;           \
  714.       MyCaos->##r5      = (ULONG) v5;           \
  715.       MyCaos->##r6      = (ULONG) v6;           \
  716.       MyCaos->a6        = (ULONG) bn;           \
  717.       MyCaos->M68kCacheMode =   cm1;            \
  718.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))   \
  719.       {                             \
  720.         MyCaos->M68kStart   =   cs1;            \
  721.         MyCaos->M68kLength  =   cl1;            \
  722.       }                             \
  723.       MyCaos->PPCCacheMode  =   cm2;            \
  724.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))   \
  725.       {                             \
  726.         MyCaos->PPCStart    =   cs2;            \
  727.         MyCaos->PPCLength   =   cl2;            \
  728.       }                             \
  729.       MyCaos->caos_Un.Offset    =   (-offs);        \
  730.       PPCCallOS (MyCaos);                   \
  731.    }                                \
  732. })
  733.  
  734. #define LP7(offs, rt, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, t5, v5, r5, t6, v6, r6, t7, v7, r7, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )  \
  735. ({                              \
  736.    struct Caos *MyCaos;                     \
  737.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  738.    {                                \
  739.       rt _##name##_re;                      \
  740.       MyCaos->##r1      = (ULONG) v1;           \
  741.       MyCaos->##r2      = (ULONG) v2;           \
  742.       MyCaos->##r3      = (ULONG) v3;           \
  743.       MyCaos->##r4      = (ULONG) v4;           \
  744.       MyCaos->##r5      = (ULONG) v5;           \
  745.       MyCaos->##r6      = (ULONG) v6;           \
  746.       MyCaos->##r7      = (ULONG) v7;           \
  747.       MyCaos->a6        = (ULONG) bn;           \
  748.       MyCaos->M68kCacheMode =   cm1;            \
  749.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))   \
  750.       {                             \
  751.         MyCaos->M68kStart   =   cs1;            \
  752.         MyCaos->M68kLength  =   cl1;            \
  753.       }                             \
  754.       MyCaos->PPCCacheMode  =   cm2;            \
  755.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))   \
  756.       {                             \
  757.         MyCaos->PPCStart    =   cs2;            \
  758.         MyCaos->PPCLength   =   cl2;            \
  759.       }                             \
  760.       MyCaos->caos_Un.Offset    =   (-offs);        \
  761.       _##name##_re = (rt) PPCCallOS (MyCaos);           \
  762.       _##name##_re;                     \
  763.    }                                \
  764. })
  765.  
  766. #define LP7NR(offs, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, t5, v5, r5, t6, v6, r6, t7, v7, r7, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  767. ({                              \
  768.    struct Caos *MyCaos;                     \
  769.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  770.    {                                \
  771.       MyCaos->##r1      = (ULONG) v1;           \
  772.       MyCaos->##r2      = (ULONG) v2;           \
  773.       MyCaos->##r3      = (ULONG) v3;           \
  774.       MyCaos->##r4      = (ULONG) v4;           \
  775.       MyCaos->##r5      = (ULONG) v5;           \
  776.       MyCaos->##r6      = (ULONG) v6;           \
  777.       MyCaos->##r7      = (ULONG) v7;           \
  778.       MyCaos->a6        = (ULONG) bn;           \
  779.       MyCaos->M68kCacheMode =   cm1;            \
  780.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))   \
  781.       {                             \
  782.         MyCaos->M68kStart   =   cs1;            \
  783.         MyCaos->M68kLength  =   cl1;            \
  784.       }                             \
  785.       MyCaos->PPCCacheMode  =   cm2;            \
  786.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))   \
  787.       {                             \
  788.         MyCaos->PPCStart    =   cs2;            \
  789.         MyCaos->PPCLength   =   cl2;            \
  790.       }                             \
  791.       MyCaos->caos_Un.Offset    =   (-offs);        \
  792.       PPCCallOS (MyCaos);                   \
  793.    }                                \
  794. })
  795.  
  796. /* Only workbench.library/AddAppIconA() */
  797. #define LP7A4(offs, rt, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, t5, v5, r5, t6, v6, r6, t7, v7, r7, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  798. ({                              \
  799.    struct Caos *MyCaos;                     \
  800.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  801.    {                                \
  802.       rt _##name##_re;                      \
  803.       MyCaos->##r1      = (ULONG) v1;           \
  804.       MyCaos->##r2      = (ULONG) v2;           \
  805.       MyCaos->##r3      = (ULONG) v3;           \
  806.       MyCaos->##r4      = (ULONG) v4;           \
  807.       MyCaos->##r5      = (ULONG) v5;           \
  808.       MyCaos->##r6      = (ULONG) v6;           \
  809.       MyCaos->##r7      = (ULONG) v7;           \
  810.       MyCaos->a6        = (ULONG) bn;           \
  811.       MyCaos->M68kCacheMode =   cm1;            \
  812.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))   \
  813.       {                             \
  814.         MyCaos->M68kStart   =   cs1;            \
  815.         MyCaos->M68kLength  =   cl1;            \
  816.       }                             \
  817.       MyCaos->PPCCacheMode  =   cm2;            \
  818.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))   \
  819.       {                             \
  820.         MyCaos->PPCStart    =   cs2;            \
  821.         MyCaos->PPCLength   =   cl2;            \
  822.       }                             \
  823.       MyCaos->caos_Un.Offset    =   (-offs);        \
  824.       _##name##_re = (rt) PPCCallOS (MyCaos);           \
  825.       _##name##_re;                     \
  826.    }                                \
  827. })
  828.  
  829. /* Would you believe that there really are beasts that need more than 7
  830.    arguments? :-) */
  831.  
  832. /* For example intuition.library/AutoRequest() */
  833. #define LP8(offs, rt, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, t5, v5, r5, t6, v6, r6, t7, v7, r7, t8, v8, r8, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )  \
  834. ({                              \
  835.    struct Caos *MyCaos;                     \
  836.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  837.    {                                \
  838.       rt _##name##_re;                      \
  839.       MyCaos->##r1      = (ULONG) v1;           \
  840.       MyCaos->##r2      = (ULONG) v2;           \
  841.       MyCaos->##r3      = (ULONG) v3;           \
  842.       MyCaos->##r4      = (ULONG) v4;           \
  843.       MyCaos->##r5      = (ULONG) v5;           \
  844.       MyCaos->##r6      = (ULONG) v6;           \
  845.       MyCaos->##r7      = (ULONG) v7;           \
  846.       MyCaos->##r8      = (ULONG) v8;           \
  847.       MyCaos->a6        = (ULONG) bn;           \
  848.       MyCaos->M68kCacheMode =   cm1;            \
  849.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))   \
  850.       {                             \
  851.         MyCaos->M68kStart   =   cs1;            \
  852.         MyCaos->M68kLength  =   cl1;            \
  853.       }                             \
  854.       MyCaos->PPCCacheMode  =   cm2;            \
  855.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))   \
  856.       {                             \
  857.         MyCaos->PPCStart    =   cs2;            \
  858.         MyCaos->PPCLength   =   cl2;            \
  859.       }                             \
  860.       MyCaos->caos_Un.Offset    =   (-offs);        \
  861.       _##name##_re = (rt) PPCCallOS (MyCaos);           \
  862.       _##name##_re;                     \
  863.    }                                \
  864. })
  865.  
  866. /* For example intuition.library/ModifyProp() */
  867. #define LP8NR(offs, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, t5, v5, r5, t6, v6, r6, t7, v7, r7, t8, v8, r8, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  868. ({                              \
  869.    struct Caos *MyCaos;                     \
  870.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  871.    {                                \
  872.       MyCaos->##r1      = (ULONG) v1;           \
  873.       MyCaos->##r2      = (ULONG) v2;           \
  874.       MyCaos->##r3      = (ULONG) v3;           \
  875.       MyCaos->##r4      = (ULONG) v4;           \
  876.       MyCaos->##r5      = (ULONG) v5;           \
  877.       MyCaos->##r6      = (ULONG) v6;           \
  878.       MyCaos->##r7      = (ULONG) v7;           \
  879.       MyCaos->##r8      = (ULONG) v8;           \
  880.       MyCaos->a6        = (ULONG) bn;           \
  881.       MyCaos->M68kCacheMode =   cm1;            \
  882.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))   \
  883.       {                             \
  884.         MyCaos->M68kStart   =   cs1;            \
  885.         MyCaos->M68kLength  =   cl1;            \
  886.       }                             \
  887.       MyCaos->PPCCacheMode  =   cm2;            \
  888.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))   \
  889.       {                             \
  890.         MyCaos->PPCStart    =   cs2;            \
  891.         MyCaos->PPCLength   =   cl2;            \
  892.       }                             \
  893.       MyCaos->caos_Un.Offset    =   (-offs);        \
  894.       PPCCallOS (MyCaos);                   \
  895.    }                                \
  896. })
  897.  
  898. /* For example layers.library/CreateUpfrontHookLayer() */
  899. #define LP9(offs, rt, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, t5, v5, r5, t6, v6, r6, t7, v7, r7, t8, v8, r8, t9, v9, r9, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )  \
  900. ({                              \
  901.    struct Caos *MyCaos;                     \
  902.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  903.    {                                \
  904.       rt _##name##_re;                      \
  905.       MyCaos->##r1      = (ULONG) v1;           \
  906.       MyCaos->##r2      = (ULONG) v2;           \
  907.       MyCaos->##r3      = (ULONG) v3;           \
  908.       MyCaos->##r4      = (ULONG) v4;           \
  909.       MyCaos->##r5      = (ULONG) v5;           \
  910.       MyCaos->##r6      = (ULONG) v6;           \
  911.       MyCaos->##r7      = (ULONG) v7;           \
  912.       MyCaos->##r8      = (ULONG) v8;           \
  913.       MyCaos->##r9      = (ULONG) v9;           \
  914.       MyCaos->a6        = (ULONG) bn;           \
  915.       MyCaos->M68kCacheMode =   cm1;            \
  916.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))   \
  917.       {                             \
  918.         MyCaos->M68kStart   =   cs1;            \
  919.         MyCaos->M68kLength  =   cl1;            \
  920.       }                             \
  921.       MyCaos->PPCCacheMode  =   cm2;            \
  922.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))   \
  923.       {                             \
  924.         MyCaos->PPCStart    =   cs2;            \
  925.         MyCaos->PPCLength   =   cl2;            \
  926.       }                             \
  927.       MyCaos->caos_Un.Offset    =   (-offs);        \
  928.       _##name##_re = (rt) PPCCallOS (MyCaos);           \
  929.       _##name##_re;                     \
  930.    }                                \
  931. })
  932.  
  933. /* For example intuition.library/NewModifyProp() */
  934. #define LP9NR(offs, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, t5, v5, r5, t6, v6, r6, t7, v7, r7, t8, v8, r8, t9, v9, r9, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  935. ({                              \
  936.    struct Caos *MyCaos;                     \
  937.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  938.    {                                \
  939.       MyCaos->##r1      = (ULONG) v1;           \
  940.       MyCaos->##r2      = (ULONG) v2;           \
  941.       MyCaos->##r3      = (ULONG) v3;           \
  942.       MyCaos->##r4      = (ULONG) v4;           \
  943.       MyCaos->##r5      = (ULONG) v5;           \
  944.       MyCaos->##r6      = (ULONG) v6;           \
  945.       MyCaos->##r7      = (ULONG) v7;           \
  946.       MyCaos->##r8      = (ULONG) v8;           \
  947.       MyCaos->##r9      = (ULONG) v9;           \
  948.       MyCaos->a6        = (ULONG) bn;           \
  949.       MyCaos->M68kCacheMode =   cm1;            \
  950.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))   \
  951.       {                             \
  952.         MyCaos->M68kStart   =   cs1;            \
  953.         MyCaos->M68kLength  =   cl1;            \
  954.       }                             \
  955.       MyCaos->PPCCacheMode  =   cm2;            \
  956.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))   \
  957.       {                             \
  958.         MyCaos->PPCStart    =   cs2;            \
  959.         MyCaos->PPCLength   =   cl2;            \
  960.       }                             \
  961.       MyCaos->caos_Un.Offset    =   (-offs);        \
  962.       PPCCallOS (MyCaos);                   \
  963.    }                                \
  964. })
  965.  
  966. /* LP10 not needed... */
  967.  
  968. /* Only graphics.library/BltMaskBitMapRastPort() */
  969. #define LP10NR(offs, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, t5, v5, r5, t6, v6, r6, t7, v7, r7, t8, v8, r8, t9, v9, r9, t10, v10, r10, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )    \
  970. ({                              \
  971.    struct Caos *MyCaos;                     \
  972.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  973.    {                                \
  974.       MyCaos->##r1      = (ULONG) v1;           \
  975.       MyCaos->##r2      = (ULONG) v2;           \
  976.       MyCaos->##r3      = (ULONG) v3;           \
  977.       MyCaos->##r4      = (ULONG) v4;           \
  978.       MyCaos->##r5      = (ULONG) v5;           \
  979.       MyCaos->##r6      = (ULONG) v6;           \
  980.       MyCaos->##r7      = (ULONG) v7;           \
  981.       MyCaos->##r8      = (ULONG) v8;           \
  982.       MyCaos->##r9      = (ULONG) v9;           \
  983.       MyCaos->##r10     = (ULONG) v10;          \
  984.       MyCaos->a6        = (ULONG) bn;           \
  985.       MyCaos->M68kCacheMode =   cm1;            \
  986.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))   \
  987.       {                             \
  988.         MyCaos->M68kStart   =   cs1;            \
  989.         MyCaos->M68kLength  =   cl1;            \
  990.       }                             \
  991.       MyCaos->PPCCacheMode  =   cm2;            \
  992.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))   \
  993.       {                             \
  994.         MyCaos->PPCStart    =   cs2;            \
  995.         MyCaos->PPCLength   =   cl2;            \
  996.       }                             \
  997.       MyCaos->caos_Un.Offset    =   (-offs);        \
  998.       PPCCallOS (MyCaos);                   \
  999.    }                                \
  1000. })
  1001.  
  1002. /* Only graphics.library/BltBitMap() */
  1003. #define LP11(offs, rt, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, t5, v5, r5, t6, v6, r6, t7, v7, r7, t8, v8, r8, t9, v9, r9, t10, v10, r10, t11, v11, r11, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )   \
  1004. ({                              \
  1005.    struct Caos *MyCaos;                     \
  1006.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  1007.    {                                \
  1008.       rt _##name##_re;                      \
  1009.       MyCaos->##r1      = (ULONG) v1;           \
  1010.       MyCaos->##r2      = (ULONG) v2;           \
  1011.       MyCaos->##r3      = (ULONG) v3;           \
  1012.       MyCaos->##r4      = (ULONG) v4;           \
  1013.       MyCaos->##r5      = (ULONG) v5;           \
  1014.       MyCaos->##r6      = (ULONG) v6;           \
  1015.       MyCaos->##r7      = (ULONG) v7;           \
  1016.       MyCaos->##r8      = (ULONG) v8;           \
  1017.       MyCaos->##r9      = (ULONG) v9;           \
  1018.       MyCaos->##r10     = (ULONG) v10;          \
  1019.       MyCaos->##r11     = (ULONG) v11;          \
  1020.       MyCaos->a6        = (ULONG) bn;           \
  1021.       MyCaos->M68kCacheMode =   cm1;            \
  1022.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))   \
  1023.       {                             \
  1024.         MyCaos->M68kStart   =   cs1;            \
  1025.         MyCaos->M68kLength  =   cl1;            \
  1026.       }                             \
  1027.       MyCaos->PPCCacheMode  =   cm2;            \
  1028.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))   \
  1029.       {                             \
  1030.         MyCaos->PPCStart    =   cs2;            \
  1031.         MyCaos->PPCLength   =   cl2;            \
  1032.       }                             \
  1033.       MyCaos->caos_Un.Offset    =   (-offs);        \
  1034.       _##name##_re = (rt) PPCCallOS (MyCaos);           \
  1035.       _##name##_re;                     \
  1036.    }                                \
  1037. })
  1038.  
  1039. #define LP10(offs, rt, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, t5, v5, r5, t6, v6, r6, t7, v7, r7, t8, v8, r8, t9, v9, r9, t10, v10, r10, bt, bn, cm1, cs1, cl1, cm2, cs2, cl2 )  \
  1040. ({                              \
  1041.    struct Caos *MyCaos;                     \
  1042.    MyCaos = (struct Caos *) ((unsigned long int) ((char *) alloca (sizeof (struct Caos) + 31) + 31) & ~31); \
  1043.    {                                \
  1044.       rt _##name##_re;                      \
  1045.       MyCaos->##r1      = (ULONG) v1;           \
  1046.       MyCaos->##r2      = (ULONG) v2;           \
  1047.       MyCaos->##r3      = (ULONG) v3;           \
  1048.       MyCaos->##r4      = (ULONG) v4;           \
  1049.       MyCaos->##r5      = (ULONG) v5;           \
  1050.       MyCaos->##r6      = (ULONG) v6;           \
  1051.       MyCaos->##r7      = (ULONG) v7;           \
  1052.       MyCaos->##r8      = (ULONG) v8;           \
  1053.       MyCaos->##r9      = (ULONG) v9;           \
  1054.       MyCaos->##r10     = (ULONG) v10;          \
  1055.       MyCaos->a6        = (ULONG) bn;           \
  1056.       MyCaos->M68kCacheMode =   cm1;            \
  1057.       if ((cm1==IF_CACHEFLUSHAREA) || (cm1==IF_CACHEINVALIDAREA))   \
  1058.       {                             \
  1059.         MyCaos->M68kStart   =   cs1;            \
  1060.         MyCaos->M68kLength  =   cl1;            \
  1061.       }                             \
  1062.       MyCaos->PPCCacheMode  =   cm2;            \
  1063.       if ((cm2==IF_CACHEFLUSHAREA) || (cm2==IF_CACHEINVALIDAREA))   \
  1064.       {                             \
  1065.         MyCaos->PPCStart    =   cs2;            \
  1066.         MyCaos->PPCLength   =   cl2;            \
  1067.       }                             \
  1068.       MyCaos->caos_Un.Offset    =   (-offs);        \
  1069.       _##name##_re = (rt) PPCCallOS (MyCaos);           \
  1070.       _##name##_re;                     \
  1071.    }                                \
  1072. })
  1073.  
  1074. #else /* WARPUP */
  1075.  
  1076. #include <powerpc/powerpc_protos.h>
  1077.  
  1078. struct PPCArgs2 {
  1079.         APTR  PP_Code;          /* Code Entry / Basevariable (OS Callback) */
  1080.         LONG  PP_Offset;        /* Offset into Library-Jumptable (OS Callback) */
  1081.         ULONG PP_Flags;         /* see below */
  1082.         APTR  PP_Stack;         /* Pointer to first argument to be copied or NULL */
  1083.         ULONG PP_StackSize;     /* Size of stack area to be copied or 0 */
  1084.         //ULONG PP_Regs[15];      /* Registervalues to be transferred */
  1085.         ULONG   d0;
  1086.         ULONG   d1;
  1087.         ULONG   d2;
  1088.         ULONG   d3;
  1089.         ULONG   d4;
  1090.         ULONG   d5;
  1091.         ULONG   d6;
  1092.         ULONG   d7;
  1093.         ULONG   a0;
  1094.         ULONG   a1;
  1095.         ULONG   a2;
  1096.         ULONG   a3;
  1097.         ULONG   a4;
  1098.         ULONG   a5;
  1099.         ULONG   a6;
  1100.         DOUBLE PP_FRegs[8];     /* FPU Registervalues to be transferred */
  1101. };
  1102.  
  1103. #define LP0NR(offs, name, bt, bn)\
  1104. ({                              \
  1105.    struct PPCArgs2 *MyArgs;                     \
  1106.    MyArgs = (struct PPCArgs2 *) ((unsigned long int) ((char *) alloca (sizeof (struct PPCArgs2) + 31) + 31) & ~31); \
  1107.    {                                \
  1108.       MyArgs->a6        = (ULONG) bn;           \
  1109.       MyArgs->PP_Offset     = (-offs);          \
  1110.       MyArgs->PP_Code       = (APTR)MyArgs->a6;         \
  1111.       MyArgs->PP_Stack      = (APTR)0L;             \
  1112.       MyArgs->PP_StackSize  = 0L;               \
  1113.       MyArgs->PP_Flags      = 0L;               \
  1114.       Run68k((struct PPCArgs *)MyArgs);                     \
  1115.    }                                \
  1116. })
  1117.  
  1118. #define LP0(offs, rt, name, bt, bn)\
  1119. ({                              \
  1120.    struct PPCArgs2 *MyArgs;                     \
  1121.    MyArgs = (struct PPCArgs2 *) ((unsigned long int) ((char *) alloca (sizeof (struct PPCArgs2) + 31) + 31) & ~31); \
  1122.    {                                \
  1123.       rt _##name##_re;                      \
  1124.       MyArgs->a6        = (ULONG) bn;           \
  1125.       MyArgs->PP_Offset     = (-offs);          \
  1126.       MyArgs->PP_Code       = (APTR)MyArgs->a6;         \
  1127.       MyArgs->PP_Stack      = (APTR)0L;             \
  1128.       MyArgs->PP_StackSize  = 0L;               \
  1129.       MyArgs->PP_Flags      = 0L;               \
  1130.       Run68k((struct PPCArgs *)MyArgs);                     \
  1131.       _##name##_re = (rt) MyArgs->d0;               \
  1132.       _##name##_re;                     \
  1133.    }                                \
  1134. })
  1135.  
  1136. #define LP1(offs, rt, name, t1, v1, r1, bt, bn)\
  1137. ({                              \
  1138.    struct PPCArgs2 *MyArgs;                     \
  1139.    MyArgs = (struct PPCArgs2 *) ((unsigned long int) ((char *) alloca (sizeof (struct PPCArgs2) + 31) + 31) & ~31); \
  1140.    {                                \
  1141.       rt _##name##_re;                      \
  1142.       MyArgs->##r1      = (ULONG) v1;           \
  1143.       MyArgs->a6        = (ULONG) bn;           \
  1144.       MyArgs->PP_Offset     = (-offs);          \
  1145.       MyArgs->PP_Code       = (APTR)MyArgs->a6;         \
  1146.       MyArgs->PP_Stack      = (APTR)0L;             \
  1147.       MyArgs->PP_StackSize  = 0L;               \
  1148.       MyArgs->PP_Flags      = 0L;               \
  1149.       Run68k((struct PPCArgs *)MyArgs);                     \
  1150.       _##name##_re = (rt) MyArgs->d0;               \
  1151.       _##name##_re;                     \
  1152.    }                                \
  1153. })
  1154.  
  1155. #define LP1NR(offs, name, t1, v1, r1, bt, bn)\
  1156. ({                              \
  1157.    struct PPCArgs2 *MyArgs;                     \
  1158.    MyArgs = (struct PPCArgs2 *) ((unsigned long int) ((char *) alloca (sizeof (struct PPCArgs2) + 31) + 31) & ~31); \
  1159.    {                                \
  1160.       MyArgs->##r1      = (ULONG) v1;           \
  1161.       MyArgs->a6        = (ULONG) bn;           \
  1162.       MyArgs->PP_Offset     = (-offs);          \
  1163.       MyArgs->PP_Code       = (APTR)MyArgs->a6;         \
  1164.       MyArgs->PP_Stack      = (APTR)0L;             \
  1165.       MyArgs->PP_StackSize  = 0L;               \
  1166.       MyArgs->PP_Flags      = 0L;               \
  1167.       Run68k((struct PPCArgs *)MyArgs);                     \
  1168.    }                                \
  1169. })
  1170.  
  1171. #define LP2(offs, rt, name, t1, v1, r1, t2, v2, r2, bt, bn)\
  1172. ({                              \
  1173.    struct PPCArgs2 *MyArgs;                     \
  1174.    MyArgs = (struct PPCArgs2 *) ((unsigned long int) ((char *) alloca (sizeof (struct PPCArgs2) + 31) + 31) & ~31); \
  1175.    {                                \
  1176.       rt _##name##_re;                      \
  1177.       MyArgs->##r1      = (ULONG) v1;           \
  1178.       MyArgs->##r2      = (ULONG) v2;           \
  1179.       MyArgs->a6        = (ULONG) bn;           \
  1180.       MyArgs->PP_Offset     = (-offs);          \
  1181.       MyArgs->PP_Code       = (APTR)MyArgs->a6;         \
  1182.       MyArgs->PP_Stack      = (APTR)0L;             \
  1183.       MyArgs->PP_StackSize  = 0L;               \
  1184.       MyArgs->PP_Flags      = 0L;               \
  1185.       Run68k((struct PPCArgs *)MyArgs);                     \
  1186.       _##name##_re = (rt) MyArgs->d0;               \
  1187.       _##name##_re;                     \
  1188.    }                                \
  1189. })
  1190.  
  1191. #define LP2NR(offs, name, t1, v1, r1, t2, v2, r2, bt, bn)\
  1192. ({                              \
  1193.    struct PPCArgs2 *MyArgs;                     \
  1194.    MyArgs = (struct PPCArgs2 *) ((unsigned long int) ((char *) alloca (sizeof (struct PPCArgs2) + 31) + 31) & ~31); \
  1195.    {                                \
  1196.       MyArgs->##r1      = (ULONG) v1;           \
  1197.       MyArgs->##r2      = (ULONG) v2;           \
  1198.       MyArgs->a6        = (ULONG) bn;           \
  1199.       MyArgs->PP_Offset     = (-offs);          \
  1200.       MyArgs->PP_Code       = (APTR)MyArgs->a6;         \
  1201.       MyArgs->PP_Stack      = (APTR)0L;             \
  1202.       MyArgs->PP_StackSize  = 0L;               \
  1203.       MyArgs->PP_Flags      = 0L;               \
  1204.       Run68k((struct PPCArgs *)MyArgs);                     \
  1205.    }                                \
  1206. })
  1207.  
  1208. #define LP3(offs, rt, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, bt, bn)\
  1209. ({                              \
  1210.    struct PPCArgs2 *MyArgs;                     \
  1211.    MyArgs = (struct PPCArgs2 *) ((unsigned long int) ((char *) alloca (sizeof (struct PPCArgs2) + 31) + 31) & ~31); \
  1212.    {                                \
  1213.       rt _##name##_re;                      \
  1214.       MyArgs->##r1      = (ULONG) v1;           \
  1215.       MyArgs->##r2      = (ULONG) v2;           \
  1216.       MyArgs->##r3      = (ULONG) v3;           \
  1217.       MyArgs->a6        = (ULONG) bn;           \
  1218.       MyArgs->PP_Offset     = (-offs);          \
  1219.       MyArgs->PP_Code       = (APTR)MyArgs->a6;         \
  1220.       MyArgs->PP_Stack      = (APTR)0L;             \
  1221.       MyArgs->PP_StackSize  = 0L;               \
  1222.       MyArgs->PP_Flags      = 0L;               \
  1223.       Run68k((struct PPCArgs *)MyArgs);                     \
  1224.       _##name##_re = (rt) MyArgs->d0;               \
  1225.       _##name##_re;                     \
  1226.    }                                \
  1227. })
  1228.  
  1229. #define LP3NR(offs, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, bt, bn)\
  1230. ({                              \
  1231.    struct PPCArgs2 *MyArgs;                     \
  1232.    MyArgs = (struct PPCArgs2 *) ((unsigned long int) ((char *) alloca (sizeof (struct PPCArgs2) + 31) + 31) & ~31); \
  1233.    {                                \
  1234.       MyArgs->##r1      = (ULONG) v1;           \
  1235.       MyArgs->##r2      = (ULONG) v2;           \
  1236.       MyArgs->##r3      = (ULONG) v3;           \
  1237.       MyArgs->a6        = (ULONG) bn;           \
  1238.       MyArgs->PP_Offset     = (-offs);          \
  1239.       MyArgs->PP_Code       = (APTR)MyArgs->a6;         \
  1240.       MyArgs->PP_Stack      = (APTR)0L;             \
  1241.       MyArgs->PP_StackSize  = 0L;               \
  1242.       MyArgs->PP_Flags      = 0L;               \
  1243.       Run68k((struct PPCArgs *)MyArgs);                     \
  1244.    }                                \
  1245. })
  1246.  
  1247. #define LP4(offs, rt, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, bt, bn)\
  1248. ({                              \
  1249.    struct PPCArgs2 *MyArgs;                     \
  1250.    MyArgs = (struct PPCArgs2 *) ((unsigned long int) ((char *) alloca (sizeof (struct PPCArgs2) + 31) + 31) & ~31); \
  1251.    {                                \
  1252.       rt _##name##_re;                      \
  1253.       MyArgs->##r1      = (ULONG) v1;           \
  1254.       MyArgs->##r2      = (ULONG) v2;           \
  1255.       MyArgs->##r3      = (ULONG) v3;           \
  1256.       MyArgs->##r4      = (ULONG) v4;           \
  1257.       MyArgs->a6        = (ULONG) bn;           \
  1258.       MyArgs->PP_Offset     = (-offs);          \
  1259.       MyArgs->PP_Code       = (APTR)MyArgs->a6;         \
  1260.       MyArgs->PP_Stack      = (APTR)0L;             \
  1261.       MyArgs->PP_StackSize  = 0L;               \
  1262.       MyArgs->PP_Flags      = 0L;               \
  1263.       Run68k((struct PPCArgs *)MyArgs);                     \
  1264.       _##name##_re = (rt) MyArgs->d0;               \
  1265.       _##name##_re;                     \
  1266.    }                                \
  1267. })
  1268.  
  1269. #define LP4NR(offs, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, bt, bn)\
  1270. ({                              \
  1271.    struct PPCArgs2 *MyArgs;                     \
  1272.    MyArgs = (struct PPCArgs2 *) ((unsigned long int) ((char *) alloca (sizeof (struct PPCArgs2) + 31) + 31) & ~31); \
  1273.    {                                \
  1274.       MyArgs->##r1      = (ULONG) v1;           \
  1275.       MyArgs->##r2      = (ULONG) v2;           \
  1276.       MyArgs->##r3      = (ULONG) v3;           \
  1277.       MyArgs->##r4      = (ULONG) v4;           \
  1278.       MyArgs->a6        = (ULONG) bn;           \
  1279.       MyArgs->PP_Offset     = (-offs);          \
  1280.       MyArgs->PP_Code       = (APTR)MyArgs->a6;         \
  1281.       MyArgs->PP_Stack      = (APTR)0L;             \
  1282.       MyArgs->PP_StackSize  = 0L;               \
  1283.       MyArgs->PP_Flags      = 0L;               \
  1284.       Run68k((struct PPCArgs *)MyArgs);                     \
  1285.    }                                \
  1286. })
  1287.  
  1288. #define LP5(offs, rt, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, t5, v5, r5, bt, bn)\
  1289. ({                              \
  1290.    struct PPCArgs2 *MyArgs;                     \
  1291.    MyArgs = (struct PPCArgs2 *) ((unsigned long int) ((char *) alloca (sizeof (struct PPCArgs2) + 31) + 31) & ~31); \
  1292.    {                                \
  1293.       rt _##name##_re;                      \
  1294.       MyArgs->##r1      = (ULONG) v1;           \
  1295.       MyArgs->##r2      = (ULONG) v2;           \
  1296.       MyArgs->##r3      = (ULONG) v3;           \
  1297.       MyArgs->##r4      = (ULONG) v4;           \
  1298.       MyArgs->##r5      = (ULONG) v5;           \
  1299.       MyArgs->a6        = (ULONG) bn;           \
  1300.       MyArgs->PP_Offset     = (-offs);          \
  1301.       MyArgs->PP_Code       = (APTR)MyArgs->a6;         \
  1302.       MyArgs->PP_Stack      = (APTR)0L;             \
  1303.       MyArgs->PP_StackSize  = 0L;               \
  1304.       MyArgs->PP_Flags      = 0L;               \
  1305.       Run68k((struct PPCArgs *)MyArgs);                     \
  1306.       _##name##_re = (rt) MyArgs->d0;               \
  1307.       _##name##_re;                     \
  1308.    }                                \
  1309. })
  1310.  
  1311. #define LP5NR(offs, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, t5, v5, r5, bt, bn)\
  1312. ({                              \
  1313.    struct PPCArgs2 *MyArgs;                     \
  1314.    MyArgs = (struct PPCArgs2 *) ((unsigned long int) ((char *) alloca (sizeof (struct PPCArgs2) + 31) + 31) & ~31); \
  1315.    {                                \
  1316.       MyArgs->##r1      = (ULONG) v1;           \
  1317.       MyArgs->##r2      = (ULONG) v2;           \
  1318.       MyArgs->##r3      = (ULONG) v3;           \
  1319.       MyArgs->##r4      = (ULONG) v4;           \
  1320.       MyArgs->##r5      = (ULONG) v5;           \
  1321.       MyArgs->a6        = (ULONG) bn;           \
  1322.       MyArgs->PP_Offset     = (-offs);          \
  1323.       MyArgs->PP_Code       = (APTR)MyArgs->a6;         \
  1324.       MyArgs->PP_Stack      = (APTR)0L;             \
  1325.       MyArgs->PP_StackSize  = 0L;               \
  1326.       MyArgs->PP_Flags      = 0L;               \
  1327.       Run68k((struct PPCArgs *)MyArgs);                     \
  1328.    }                                \
  1329. })
  1330.  
  1331. #define LP7(offs, rt, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, t5, v5, r5, t6, v6, r6, t7, v7, r7, bt, bn)\
  1332. ({                              \
  1333.    struct PPCArgs2 *MyArgs;                     \
  1334.    MyArgs = (struct PPCArgs2 *) ((unsigned long int) ((char *) alloca (sizeof (struct PPCArgs2) + 31) + 31) & ~31); \
  1335.    {                                \
  1336.       rt _##name##_re;                      \
  1337.       MyArgs->##r1      = (ULONG) v1;           \
  1338.       MyArgs->##r2      = (ULONG) v2;           \
  1339.       MyArgs->##r3      = (ULONG) v3;           \
  1340.       MyArgs->##r4      = (ULONG) v4;           \
  1341.       MyArgs->##r5      = (ULONG) v5;           \
  1342.       MyArgs->##r6      = (ULONG) v6;           \
  1343.       MyArgs->##r7      = (ULONG) v7;           \
  1344.       MyArgs->a6        = (ULONG) bn;           \
  1345.       MyArgs->PP_Offset     = (-offs);          \
  1346.       MyArgs->PP_Code       = (APTR)MyArgs->a6;         \
  1347.       MyArgs->PP_Stack      = (APTR)0L;             \
  1348.       MyArgs->PP_StackSize  = 0L;               \
  1349.       MyArgs->PP_Flags      = 0L;               \
  1350.       Run68k((struct PPCArgs *)MyArgs);                     \
  1351.       _##name##_re = (rt) MyArgs->d0;               \
  1352.       _##name##_re;                     \
  1353.    }                                \
  1354. })
  1355.  
  1356. #define LP10(offs, rt, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, t5, v5, r5, t6, v6, r6, t7, v7, r7, t8, v8, r8, t9, v9, r9, t10, v10, r10, bt, bn)\
  1357. ({                              \
  1358.    struct PPCArgs2 *MyArgs;                     \
  1359.    MyArgs = (struct PPCArgs2 *) ((unsigned long int) ((char *) alloca (sizeof (struct PPCArgs2) + 31) + 31) & ~31); \
  1360.    {                                \
  1361.       rt _##name##_re;                      \
  1362.       MyArgs->##r1      = (ULONG) v1;           \
  1363.       MyArgs->##r2      = (ULONG) v2;           \
  1364.       MyArgs->##r3      = (ULONG) v3;           \
  1365.       MyArgs->##r4      = (ULONG) v4;           \
  1366.       MyArgs->##r5      = (ULONG) v5;           \
  1367.       MyArgs->##r6      = (ULONG) v6;           \
  1368.       MyArgs->##r7      = (ULONG) v7;           \
  1369.       MyArgs->##r8      = (ULONG) v8;           \
  1370.       MyArgs->##r9      = (ULONG) v9;           \
  1371.       MyArgs->##r10     = (ULONG) v10;          \
  1372.       MyArgs->a6        = (ULONG) bn;           \
  1373.       MyArgs->PP_Offset     = (-offs);          \
  1374.       MyArgs->PP_Code       = (APTR)MyArgs->a6;         \
  1375.       MyArgs->PP_Stack      = (APTR)0L;             \
  1376.       MyArgs->PP_StackSize  = 0L;               \
  1377.       MyArgs->PP_Flags      = 0L;               \
  1378.       Run68k((struct PPCArgs *)MyArgs);                     \
  1379.       _##name##_re = (rt) MyArgs->d0;               \
  1380.       _##name##_re;                     \
  1381.    }                                \
  1382. })
  1383.  
  1384. #define LP11(offs, rt, name, t1, v1, r1, t2, v2, r2, t3, v3, r3, t4, v4, r4, t5, v5, r5, t6, v6, r6, t7, v7, r7, t8, v8, r8, t9, v9, r9, t10, v10, r10, t11, v11, r11, bt, bn)\
  1385. ({                              \
  1386.    struct PPCArgs2 *MyArgs;                     \
  1387.    MyArgs = (struct PPCArgs2 *) ((unsigned long int) ((char *) alloca (sizeof (struct PPCArgs2) + 31) + 31) & ~31); \
  1388.    {                                \
  1389.       rt _##name##_re;                      \
  1390.       MyArgs->##r1      = (ULONG) v1;           \
  1391.       MyArgs->##r2      = (ULONG) v2;           \
  1392.       MyArgs->##r3      = (ULONG) v3;           \
  1393.       MyArgs->##r4      = (ULONG) v4;           \
  1394.       MyArgs->##r5      = (ULONG) v5;           \
  1395.       MyArgs->##r6      = (ULONG) v6;           \
  1396.       MyArgs->##r7      = (ULONG) v7;           \
  1397.       MyArgs->##r8      = (ULONG) v8;           \
  1398.       MyArgs->##r9      = (ULONG) v9;           \
  1399.       MyArgs->##r10     = (ULONG) v10;          \
  1400.       MyArgs->##r11     = (ULONG) v11;          \
  1401.       MyArgs->a6        = (ULONG) bn;           \
  1402.       MyArgs->PP_Offset     = (-offs);          \
  1403.       MyArgs->PP_Code       = (APTR)MyArgs->a6;         \
  1404.       MyArgs->PP_Stack      = (APTR)0L;             \
  1405.       MyArgs->PP_StackSize  = 0L;               \
  1406.       MyArgs->PP_Flags      = 0L;               \
  1407.       Run68k((struct PPCArgs *)MyArgs);                     \
  1408.       _##name##_re = (rt) MyArgs->d0;               \
  1409.       _##name##_re;                     \
  1410.    }                                \
  1411. })
  1412.  
  1413. #endif
  1414.  
  1415. #endif /* __INLINE_MACROS_H */
  1416.  
  1417.  
  1418.